继承和多态

1. 概述

继承和多态是面向对象编程（OOP）中的两个核心概念。继承允许一个类（子类）继承另一个类（父类）的属性和方法，从而实现代码的重用。多态则允许子类以不同的方式实现父类的方法，使得代码更加灵活和可扩展。

2. 继承

2.1 什么是继承？

继承是一种机制，通过这种机制，一个类可以从另一个类继承属性和方法。被继承的类称为父类（或基类），继承的类称为子类（或派生类）。

2.2 继承的语法

在 Swift 中，使用 : 符号来表示继承关系。例如：

class Animal {
    var name: String
    
    init(name: String) {
        self.name = name
    }
    
    func makeSound() {
        print("Some generic animal sound")
    }
}

class Dog: Animal {
    override func makeSound() {
        print("Woof!")
    }
}

在这个例子中，Dog 类继承了 Animal 类，并重写了 makeSound 方法。

2.3 继承的优点

• 代码重用：子类可以重用父类的属性和方法，减少代码重复。
• 扩展性：可以轻松地扩展父类的功能。
• 层次结构：通过继承可以构建清晰的类层次结构。

3. 多态

3.1 什么是多态？

多态是指同一个方法在不同的类中有不同的实现。多态性允许我们使用父类的引用来调用子类的方法，从而实现灵活的代码设计。

3.2 多态的实现

在 Swift 中，多态通过方法重写（override）和类型转换（type casting）来实现。

let animals: [Animal] = [Animal(name: "Generic Animal"), Dog(name: "Buddy")]

for animal in animals {
    animal.makeSound()
}

在这个例子中，animals 数组包含了一个 Animal 对象和一个 Dog 对象。尽管我们使用 Animal 类型的引用来调用 makeSound 方法，但实际调用的是子类 Dog 的 makeSound 方法。

3.3 多态的优点

• 灵活性：可以根据对象的实际类型调用相应的方法。
• 可扩展性：可以轻松地添加新的子类，而不需要修改现有的代码。

4. 实践练习

4.1 练习1：创建一个继承层次结构

创建一个 Vehicle 类，并从中派生出 Car 和 Bike 类。每个类都应该有一个 startEngine 方法，但实现方式不同。

class Vehicle {
    func startEngine() {
        print("Vehicle engine started")
    }
}

class Car: Vehicle {
    override func startEngine() {
        print("Car engine started")
    }
}

class Bike: Vehicle {
    override func startEngine() {
        print("Bike engine started")
    }
}

let vehicles: [Vehicle] = [Car(), Bike()]

for vehicle in vehicles {
    vehicle.startEngine()
}

4.2 练习2：使用多态性

创建一个 Shape 类，并从中派生出 Circle 和 Rectangle 类。每个类都应该有一个 area 方法，但计算方式不同。

class Shape {
    func area() -> Double {
        return 0.0
    }
}

class Circle: Shape {
    var radius: Double
    
    init(radius: Double) {
        self.radius = radius
    }
    
    override func area() -> Double {
        return Double.pi * radius * radius
    }
}

class Rectangle: Shape {
    var width: Double
    var height: Double
    
    init(width: Double, height: Double) {
        self.width = width
        self.height = height
    }
    
    override func area() -> Double {
        return width * height
    }
}

let shapes: [Shape] = [Circle(radius: 5), Rectangle(width: 4, height: 6)]

for shape in shapes {
    print("Area: \(shape.area())")
}

5. 总结

继承和多态是面向对象编程中的重要概念，它们使得代码更加模块化、可重用和灵活。通过继承，我们可以构建清晰的类层次结构；通过多态，我们可以实现灵活的方法调用。掌握这两个概念对于编写高质量的 Swift 代码至关重要。

6. 下一步

在掌握了继承和多态之后，你可以继续学习 Swift 中的其他高级特性，如协议、泛型和并发编程。这些内容将进一步增强你的编程能力，帮助你构建更加复杂和强大的应用程序。